package handlers

import (
	"net/http"

	"backend-api/internal/middleware"
	"backend-api/internal/services"

	"github.com/gin-gonic/gin"
	"github.com/sirupsen/logrus"
)

// UserHandler 用户处理器
type UserHandler struct {
	userService *services.UserService
}

// NewUserHandler 创建用户处理器实例
func NewUserHandler() *UserHandler {
	return &UserHandler{
		userService: services.NewUserService(),
	}
}

// Register 用户注册
// @Summary 用户注册
// @Description 前台用户注册接口
// @Tags 前台用户
// @Accept json
// @Produce json
// @Param request body services.RegisterRequest true "注册信息"
// @Success 200 {object} map[string]interface{} "注册成功"
// @Failure 400 {object} map[string]interface{} "参数错误"
// @Router /frontend/register [post]
func (h *UserHandler) Register(c *gin.Context) {
	var req services.RegisterRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		logrus.WithError(err).Error("用户注册参数绑定失败")
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    400,
			"message": "参数错误: " + err.Error(),
			"data":    nil,
		})
		return
	}

	user, err := h.userService.Register(&req)
	if err != nil {
		logrus.WithError(err).Error("用户注册失败")
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    400,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	logrus.WithField("user_id", user.ID).Info("用户注册成功")
	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "注册成功",
		"data":    user,
	})
}

// Login 用户登录
// @Summary 用户登录
// @Description 前台用户登录接口
// @Tags 前台用户
// @Accept json
// @Produce json
// @Param request body services.LoginRequest true "登录信息"
// @Success 200 {object} map[string]interface{} "登录成功"
// @Failure 401 {object} map[string]interface{} "登录失败"
// @Router /frontend/login [post]
func (h *UserHandler) Login(c *gin.Context) {
	var req services.LoginRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		logrus.WithError(err).Error("用户登录参数绑定失败")
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    400,
			"message": "参数错误: " + err.Error(),
			"data":    nil,
		})
		return
	}

	response, err := h.userService.Login(&req)
	if err != nil {
		logrus.WithError(err).Error("用户登录失败")
		c.JSON(http.StatusUnauthorized, gin.H{
			"code":    401,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	logrus.WithField("user_id", response.User.ID).Info("用户登录成功")
	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "登录成功",
		"data":    response,
	})
}

// GetProfile 获取用户信息
// @Summary 获取用户信息
// @Description 获取当前登录用户的个人信息
// @Tags 前台用户
// @Accept json
// @Produce json
// @Security FrontendAuth
// @Success 200 {object} map[string]interface{} "获取成功"
// @Failure 401 {object} map[string]interface{} "未授权"
// @Failure 500 {object} map[string]interface{} "服务器错误"
// @Router /frontend/profile [get]
func (h *UserHandler) GetProfile(c *gin.Context) {
	userID, exists := middleware.GetCurrentUserID(c)
	if !exists {
		c.JSON(http.StatusUnauthorized, gin.H{
			"code":    401,
			"message": "未找到用户信息",
			"data":    nil,
		})
		return
	}

	user, err := h.userService.GetProfile(userID)
	if err != nil {
		logrus.WithError(err).Error("获取用户信息失败")
		c.JSON(http.StatusInternalServerError, gin.H{
			"code":    500,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "获取成功",
		"data":    user,
	})
}

// UpdateProfile 更新用户信息
// @Summary 更新用户信息
// @Description 更新当前登录用户的个人信息
// @Tags 前台用户
// @Accept json
// @Produce json
// @Security FrontendAuth
// @Param request body services.UpdateProfileRequest true "更新信息"
// @Success 200 {object} map[string]interface{} "更新成功"
// @Failure 400 {object} map[string]interface{} "参数错误"
// @Failure 401 {object} map[string]interface{} "未授权"
// @Failure 500 {object} map[string]interface{} "服务器错误"
// @Router /frontend/profile [put]
func (h *UserHandler) UpdateProfile(c *gin.Context) {
	userID, exists := middleware.GetCurrentUserID(c)
	if !exists {
		c.JSON(http.StatusUnauthorized, gin.H{
			"code":    401,
			"message": "未找到用户信息",
			"data":    nil,
		})
		return
	}

	var req services.UpdateProfileRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		logrus.WithError(err).Error("更新用户信息参数绑定失败")
		c.JSON(http.StatusBadRequest, gin.H{
			"code":    400,
			"message": "参数错误: " + err.Error(),
			"data":    nil,
		})
		return
	}

	user, err := h.userService.UpdateProfile(userID, &req)
	if err != nil {
		logrus.WithError(err).Error("更新用户信息失败")
		c.JSON(http.StatusInternalServerError, gin.H{
			"code":    500,
			"message": err.Error(),
			"data":    nil,
		})
		return
	}

	logrus.WithField("user_id", userID).Info("用户信息更新成功")
	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "更新成功",
		"data":    user,
	})
}

// Logout 用户退出登录
// @Summary 用户退出登录
// @Description 前台用户退出登录接口
// @Tags 前台用户
// @Accept json
// @Produce json
// @Security FrontendAuth
// @Success 200 {object} map[string]interface{} "退出成功"
// @Failure 401 {object} map[string]interface{} "未授权"
// @Router /frontend/logout [post]
func (h *UserHandler) Logout(c *gin.Context) {
	userID, exists := middleware.GetCurrentUserID(c)
	if !exists {
		c.JSON(http.StatusUnauthorized, gin.H{
			"code":    401,
			"message": "未找到用户信息",
			"data":    nil,
		})
		return
	}

	// 这里可以实现JWT黑名单机制，将令牌加入Redis黑名单
	// 目前简单返回成功响应
	logrus.WithField("user_id", userID).Info("用户退出登录")
	c.JSON(http.StatusOK, gin.H{
		"code":    200,
		"message": "退出登录成功",
		"data":    nil,
	})
}